tests/test_run_smoke.py (1)

80-82: ⚡ Quick win

Make the issue_id assertion deterministic for both dict/object packets.

Line 82 can raise TypeError if packet has no issue_id and is non-iterable; explicit branching gives reliable failure semantics.

Suggested fix

     assert packet is not None
-    # The triage packet should have parsed our mock log.
-    assert hasattr(packet, "issue_id") or "issue_id" in packet
+    # The triage packet should have parsed our mock log.
+    if isinstance(packet, dict):
+        assert "issue_id" in packet
+    else:
+        assert getattr(packet, "issue_id", None)

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@tests/test_run_smoke.py` around lines 80 - 82, The current assertion for
issue_id can raise TypeError for non-iterable packet objects; update the test to
branch explicitly on packet type: if packet is a dict (use isinstance(packet,
dict)) assert 'issue_id' in packet, otherwise assert hasattr(packet, "issue_id")
so both dict and object packets produce deterministic failures; locate the
assertions around the variable packet in tests/test_run_smoke.py (the two lines
asserting packet is not None and the issue_id check) and replace the single
mixed assertion with this explicit branching check.

argus/notifications/notifier.py (2)

20-26: ⚡ Quick win

Consider adding explicit timeouts to HTTP requests.

Without explicit timeouts, requests could hang indefinitely on network issues. httpx.AsyncClient accepts a timeout parameter.

♻️ Proposed fix

-        async with httpx.AsyncClient() as client:
+        async with httpx.AsyncClient(timeout=30.0) as client:
             if "slack" in bots:

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/notifications/notifier.py` around lines 20 - 26, The HTTP client usage
in the async block creates httpx.AsyncClient without a timeout which can hang;
update the AsyncClient instantiation in the notifier (where you call
_notify_slack, _notify_discord, _notify_telegram) to pass an explicit timeout
(e.g., httpx.Timeout or a seconds value) so all requests from that client have a
sensible connect/read/write overall timeout; ensure the timeout value is
configurable or a reasonable default and apply it when creating the AsyncClient
used by those three notify methods.

---

76-82: ⚡ Quick win

Telegram token parsing is fragile; use rsplit for robustness.

Standard Telegram bot tokens contain one colon (e.g., 123456789:ABC-defGHI...). The current split(":") approach works for tokens with exactly one colon, but using rsplit with maxsplit=1 to extract the chat_id from the end would be more robust.

♻️ Proposed improvement

-        if ":" in token and len(token.split(":")) >= 2:
-            parts = token.split(":")
-            bot_token = f"{parts[0]}:{parts[1]}"
-            chat_id = parts[2] if len(parts) > 2 else "0"
+        # Expected format: "bot_token:chat_id" where bot_token itself contains one colon
+        # Split from the right to separate chat_id from bot_token
+        if ":" in token:
+            bot_token, sep, chat_id = token.rpartition(":")
+            if not bot_token or not chat_id:
+                bot_token = token
+                chat_id = "0"
         else:
             bot_token = token
             chat_id = "0"

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/notifications/notifier.py` around lines 76 - 82, The token parsing is
fragile; replace the split-based logic with an rsplit-based split to separate a
possible trailing chat_id: call token.rsplit(":", 1) and if it returns two parts
set bot_token = parts[0] and chat_id = parts[1], otherwise set bot_token = token
and chat_id = "0"; update the block that currently assigns bot_token and chat_id
(the token parsing code using token.split(":") and the variables bot_token and
chat_id in notifier.py) so tokens containing additional colons are preserved
correctly while extracting a trailing chat_id robustly.

argus/cli/main.py (1)

141-144: 💤 Low value

Runtime sys.path manipulation is fragile.

Inserting into sys.path at runtime can cause import conflicts and makes the code harder to maintain. Consider making main a proper package import or using relative imports within the package structure.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/cli/main.py` around lines 141 - 144, The runtime sys.path insertion in
argus/cli/main.py (sys.path.insert(...)) is fragile; remove that manipulation
and import run_pipeline and notify via proper package or relative imports
instead (e.g., convert the top-level script into a package entrypoint and use
from argus.main import run_pipeline or a relative import like from ..main import
run_pipeline), and update the CLI entrypoint (setup/pyproject or invocation with
python -m argus.cli.main) so imports resolve without touching sys.path; ensure
argus.notifications.notifier.notify remains imported as a normal package import.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

argus/resilience/resilience_manager.py (1)

241-241: ⚡ Quick win

Revert the widened return type to None.

reset_all_circuit_breakers does not return a value—it only delegates to the manager. Widening from -> None to -> Any loses type precision without benefit.

♻️ Proposed fix

-    def reset_all_circuit_breakers(self) -> Any:
+    def reset_all_circuit_breakers(self) -> None:

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/resilience/resilience_manager.py` at line 241, The return type of
reset_all_circuit_breakers was widened to Any but the function doesn't return
anything; change its signature back to return None by updating the type
annotation on def reset_all_circuit_breakers(self) -> None:. Ensure no return
value is added inside the method body and keep any delegation to the manager
(e.g., self._manager.reset_all_circuit_breakers or similar) unchanged so the
method remains a void wrapper with precise typing.

argus/source_control/error_handling/error_patterns.py (1)

55-55: ⚡ Quick win

Revert the widened protocol return type to None.

All implementations of compile_patterns (lines 122, 245, 385) return None. Widening the PatternMatcher protocol to -> Any weakens the contract and allows implementers to return arbitrary values, reducing type safety for callers.

♻️ Proposed fix

-    def compile_patterns(self) -> Any:
+    def compile_patterns(self) -> None:

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/source_control/error_handling/error_patterns.py` at line 55, The
PatternMatcher protocol's compile_patterns return type was widened to Any;
revert it to -> None to restore the original contract (since all
implementations—compile_patterns in the classes referenced by the
protocol—return None). Update the protocol signature for compile_patterns to
return None (not Any), and keep existing implementations in methods named
compile_patterns (the ones at or near lines 122, 245, 385) unchanged so callers
can rely on a None return type for type safety. Ensure any type hints/imports
reflect the None return (remove Any usage from that signature).

argus/source_control/error_handling/error_classification.py (1)

392-392: ⚡ Quick win

Revert the widened return type to None.

reset_metrics does not return a value—it only delegates to the collector. Widening from -> None to -> Any loses type precision without benefit.

♻️ Proposed fix

-    def reset_metrics(self) -> Any:
+    def reset_metrics(self) -> None:

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/source_control/error_handling/error_classification.py` at line 392, The
return annotation of reset_metrics was widened to Any but the method never
returns a value; change the signature of reset_metrics back to -> None (i.e.,
def reset_metrics(self) -> None:) to restore precise typing, and update any
corresponding type hints or overrides (e.g., in the containing class or
subclasses) that relied on the old annotation so they remain consistent with
reset_metrics delegating to the collector and not returning anything.

argus/pattern_detector/time_window_accumulator.py (1)

38-38: ⚡ Quick win

Revert the widened return type to None.

start does not return a value—it only starts a background task. Widening from -> None to -> Any loses type precision without benefit.

♻️ Proposed fix

-    def start(self) -> Any:
+    def start(self) -> None:

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/pattern_detector/time_window_accumulator.py` at line 38, The return
type for the start method was widened to Any but it doesn't return anything;
change the signature of the start function back to return None (i.e., def
start(self) -> None:) to restore precise typing for the background-task starter
in class/method start in time_window_accumulator.py and update any related type
hints if they relied on the widened type.

argus/ml/adaptive_rate_limiter.py (1)

246-246: ⚡ Quick win

Revert the widened return type to None.

reset_stats does not return a value—it only mutates instance fields. Widening the annotation from -> None to -> Any loses type precision without benefit.

♻️ Proposed fix

-    def reset_stats(self) -> Any:
+    def reset_stats(self) -> None:

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/ml/adaptive_rate_limiter.py` at line 246, The return type of the method
reset_stats was widened to Any but the method mutates instance fields and
returns nothing; update the function signature of reset_stats to annotate the
return type as -> None (replace Any with None) so the type reflects no return
value and restores type precision for callers and static checkers.

argus/security/data_filter.py (1)

61-61: ⚡ Quick win

Retain None return type for initializer helper.

_initialize_default_rules() is mutative and returns nothing; -> Any obscures that contract.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/security/data_filter.py` at line 61, The helper
_initialize_default_rules is mutative and should explicitly indicate it returns
nothing; change its signature from "def _initialize_default_rules(self) -> Any:"
to use a None return type (-> None) and ensure it does not return a value;
update the type hint only (keep the mutating logic in _initialize_default_rules
as-is) so callers and linters see the correct contract.

argus/source_control/base.py (1)

175-175: ⚡ Quick win

Avoid broadening core provider lifecycle methods to Any.

initialize() and ensure_initialized() are side-effect lifecycle methods; Any weakens the base contract across all implementations/callers. Keep these as -> None.

Suggested diff

-    async def initialize(self) -> Any:
+    async def initialize(self) -> None:
...
-    async def ensure_initialized(self) -> Any:
+    async def ensure_initialized(self) -> None:

Also applies to: 210-210

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/source_control/base.py` at line 175, Change the lifecycle method return
types from Any to None: update the async def initialize(self) and async def
ensure_initialized(self) signatures in the class to return -> None (and adjust
any related type hints/imports). Ensure all implementations/overrides of
initialize and ensure_initialized in subclasses conform to returning None (i.e.,
perform side effects but do not return values) and update any callers that
relied on a return value to stop using it.

argus/ml/workflow/workflow_metrics.py (1)

388-388: ⚡ Quick win

Keep lifecycle return contract explicit (-> None).

initialize() does not return a value, so -> Any weakens type guarantees and can hide contract drift with ProcessableComponent. Prefer -> None.

Suggested diff

-    def initialize(self) -> Any:
+    def initialize(self) -> None:

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/ml/workflow/workflow_metrics.py` at line 388, The initialize method's
signature uses a broad return type (def initialize(self) -> Any) which weakens
the lifecycle contract; change the return annotation to explicit None (def
initialize(self) -> None) to match the ProcessableComponent lifecycle
expectation and make it clear no value is returned. Locate the initialize method
in the WorkflowMetrics class (or the class defining initialize in
workflow_metrics.py) and update its type hint accordingly, adjust any callers if
they incorrectly expect a value, and run type checks (mypy/pytest) to ensure no
downstream type errors.

argus/security/config_manager.py (1)

92-92: ⚡ Quick win

Use -> None for _load_keys instead of Any.

This coroutine is side-effect only; Any reduces type-safety without benefit.

Suggested diff

-    async def _load_keys(self) -> Any:
+    async def _load_keys(self) -> None:

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/security/config_manager.py` at line 92, Change the coroutine signature
of _load_keys from returning Any to returning None to reflect that it is
side-effect only: update the async def _load_keys(...) -> Any to async def
_load_keys(...) -> None and ensure the implementation and any callers do not
rely on or return a value (remove accidental return expressions if present);
keep the method name _load_keys and its behavior unchanged otherwise.

argus/source_control/enhanced_base_implementation.py (1)

144-144: ⚡ Quick win

Match override return type with base abstract contract.

_setup_client in the base class is -> None; this override using -> Any introduces avoidable contract drift.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/source_control/enhanced_base_implementation.py` at line 144, The
override _setup_client currently declares a return type of Any which drifts from
the base abstract contract that specifies -> None; update the async def
_setup_client signature to return None (async def _setup_client(self) -> None)
and ensure the method does not return any value (remove or adjust any return
statements) so it matches the base class's contract.

argus/source_control/repository_manager.py (1)

26-26: ⚡ Quick win

Use explicit None for repository manager initialization.

initialize() is lifecycle setup with no return value; -> Any reduces API clarity and type safety.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/source_control/repository_manager.py` at line 26, The initialize method
currently declares a vague return type Any—change its signature to async def
initialize(self) -> None: to make the lifecycle intent explicit, remove any
accidental return values inside RepositoryManager.initialize (ensure no return
statements that return values), and update any callers or type hints that expect
a value to handle a None return; also adjust imports/types if you had annotated
variables with Any specifically for this method.

argus/ingestion/monitoring/performance.py (1)

108-115: ⚡ Quick win

Return type degradation: -> Any is less precise than -> None for async void methods.

Both start() and _update_metrics_periodically() are async methods that do not return values. Changing from -> None to -> Any loses type precision and makes the API less clear.

♻️ Revert to more precise return types

-    async def start(self) -> Any:
+    async def start(self) -> None:
         """Start the performance monitor."""

-    async def _update_metrics_periodically(self) -> Any:
+    async def _update_metrics_periodically(self) -> None:
         """Background task to update metrics periodically."""

Also applies to: 366-382

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/ingestion/monitoring/performance.py` around lines 108 - 115, The async
methods use a non-specific return type; change the type hints from -> Any to ->
None for the async methods to restore precision: update the signature of
start(self) to "async def start(self) -> None" and likewise change
"_update_metrics_periodically(self)" and the other async method referenced in
the review (lines 366-382) to "-> None"; ensure any related type hints or stubs
that reference these functions are adjusted to expect None return values.

argus/llm/prompt_manager.py (1)

40-57: ⚡ Quick win

Return type degradation: -> Any is less precise than -> None.

The _load_prompts() method does not return a value (has early return on line 45 and implicit None at end). Changing from -> None to -> Any loses type precision.

♻️ Revert to the more precise return type

-    def _load_prompts(self) -> Any:
+    def _load_prompts(self) -> None:
         """Load prompts from the prompt directory."""

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/llm/prompt_manager.py` around lines 40 - 57, The _load_prompts method
currently uses a loose return annotation "-> Any" even though it never returns a
value; change the function signature of _load_prompts to "-> None" and keep the
existing early return paths as-is (or add an explicit "return None" if you
prefer explicitness) so the type accurately reflects that it produces no return
value; update the annotation where def _load_prompts(...) is declared and ensure
any callers or stubs expecting a value are not relying on a return from
_load_prompts.

argus/llm/mixing/performance_optimizer.py (1)

98-101: ⚡ Quick win

Return type degradation: -> Any is less precise than -> None for void methods.

Both touch() and reset_performance_metrics() are methods that do not return values. Changing from -> None to -> Any loses type precision.

♻️ Revert to more precise return types

-    def touch(self) -> Any:
+    def touch(self) -> None:
         """Update access information."""

-    def reset_performance_metrics(self) -> Any:
+    def reset_performance_metrics(self) -> None:
         """Reset all performance metrics."""

Also applies to: 619-624

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/llm/mixing/performance_optimizer.py` around lines 98 - 101, The touch()
and reset_performance_metrics() methods were annotated as returning Any but they
are void; change their return type annotations to -> None to restore type
precision (update the touch method and the reset_performance_metrics method in
the same class so both signatures use -> None).

argus/legacy_config.py (1)

52-64: ⚡ Quick win

Type safety regression: Pydantic validators should use specific types, not Any.

The validator signatures were changed from cls: str, v: str -> None to cls: Any, v: Any -> Any. While the old -> None was incorrect (validators must return the validated value), using Any for all parameters loses Pydantic's type validation benefits. The correct Pydantic v2 pattern is:

`@field_validator`("field_name")
`@classmethod`
def validate_field(cls, v: str) -> str:
    # validate and return v
    return v

Using Any disables static type checking and makes the codebase harder to maintain.

♻️ Restore specific type annotations

     `@field_validator`("project_id")
     `@classmethod`
-    def validate_project_id(cls: Any, v: Any) -> Any:
+    def validate_project_id(cls, v: str) -> str:
         """
         Validate Project Id.

     `@field_validator`("subscription_id")
     `@classmethod`
-    def validate_subscription_id(cls: Any, v: Any) -> Any:
+    def validate_subscription_id(cls, v: str) -> str:
         """
         Validate Subscription Id.

     `@field_validator`("service_name")
     `@classmethod`
-    def validate_service_name(cls: Any, v: Any) -> Any:
+    def validate_service_name(cls, v: str) -> str:
         """
         Validate Service Name.

Also applies to: 67-79, 82-96

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/legacy_config.py` around lines 52 - 64, The validator
validate_project_id currently uses Any for parameters and return type which
loses type safety; update its signature to match Pydantic v2 patterns by using
concrete types: annotate as `@classmethod` def validate_project_id(cls, v: str) ->
str, perform the length checks and return v (raise ValueError as before). Apply
the same change to the other validators referenced (lines 67-79 and 82-96) so
each validator parameter and return use specific types (e.g., str or int as
appropriate) instead of Any and ensure they return the validated value.

argus/llm/enhanced_service.py (1)

1057-1060: ⚡ Quick win

Return type degradation: -> Any is less precise than -> None.

The initialize_services() async method does not return a value. Changing from -> None to -> Any loses type precision.

♻️ Revert to the more precise return type

-    async def initialize_services(self) -> Any:
+    async def initialize_services(self) -> None:
         """Initialize the service manager and all services."""

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/llm/enhanced_service.py` around lines 1057 - 1060, The async method
initialize_services currently uses a broad return annotation "-> Any" even
though it doesn't return a value; update the type annotation to "-> None" on the
initialize_services declaration to restore precise typing (locate the
initialize_services method in enhanced_service.py and change its return type
from Any to None).

argus/llm/config.py (1)

43-71: 🏗️ Heavy lift

Systematic type safety regression: All Pydantic validators widened to Any.

This file contains extensive changes where all @field_validator and @model_validator methods have been widened from specific types to cls: Any, v: Any -> Any (or added info: Any where applicable). While the PR summary acknowledges this is intentional, it represents a significant loss of type safety:

1. Field validators should declare the actual field type to enable static checking
2. Model validators should return Self to preserve the model type
3. Using Any disables mypy/pyright validation of validator logic

This change makes it impossible for type checkers to catch:

• Incorrect return types from validators
• Type mismatches in validation logic
• Breaking changes to field types

Consider reverting to specific types or using TypeVar-based generic signatures to preserve type safety while accommodating Pydantic V2 requirements.

Also applies to: 101-212, 243-331, 405-517, 540-552, 585-707

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/llm/config.py` around lines 43 - 71, The validators were loosened to
use Any, which loses static type safety; restore precise type annotations for
each validator (e.g., for validate_name use v: str and return str, for
validate_capabilities use v: Optional[Iterable[str]] and return list[str]) and
update model-level validators to return the model type (use Self/TypeVar-bounded
return) instead of Any; apply the same fix across all field/model validators
referenced (e.g., validate_name, validate_capabilities and the other validators
in the ranges noted) so mypy/pyright can validate input and return types while
keeping Pydantic V2-compatible signatures.

argus/core/logging/context.py (1)

102-106: ⚡ Quick win

Return type degradation: -> Any is less precise than -> None.

The finish() method does not return a value (implicit None). Changing the annotation from -> None to -> Any loses type precision and makes the API contract less clear to callers.

♻️ Revert to the more precise return type

-    def finish(self) -> Any:
+    def finish(self) -> None:
         """Mark the context as finished and calculate duration."""
         self.end_time = datetime.now()
         if self.start_time:
             self.duration = (self.end_time - self.start_time).total_seconds()

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@argus/core/logging/context.py` around lines 102 - 106, The finish method's
return annotation is too broad (-> Any) but the method does not return anything;
update the signature of finish to return -> None (change the annotation on
method finish in class/context.py), ensure there are no explicit return values
inside finish, and run type checks to verify callers and stubs remain correct
(refer to the finish method and its start_time/end_time/duration handling).